from django.conf import settings
import json
from typing import Dict, List, Optional, Union, Tuple
import logging
from apps.note.models import Note, Category
from django.contrib.auth import get_user_model
from .ocr_service import OCRService
import requests

User = get_user_model()
logger = logging.getLogger('apps')

class AIManager:
    """智能效率管理助手"""
    
    def __init__(self):
        self.config = settings.AI_CONFIG
        
        # 初始化OCR服务
        self.ocr_service = OCRService()
        
        # AI API 配置
        self.api_key = settings.AI_API_KEY
        self.api_base = settings.AI_API_BASE
        self.headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        
        self.model_config = {
            'general': {
                'temperature': 0.7,
                'max_tokens': 1000
            },
            'plan': {
                'temperature': 0.4,
                'max_tokens': 1500
            },
            'optimization': {
                'temperature': 0.3,
                'max_tokens': 2000
            }
        }
    
    def call_ai_api(self, prompt: str, temperature: float = None, max_tokens: int = None) -> str:
        """调用 AI API"""
        try:
            url = f"{self.api_base}/chat/completions"
            
            # 使用配置中的默认值或传入的参数
            payload = {
                "model": self.ai_config['model'],
                "messages": [{"role": "user", "content": prompt}],
                "temperature": temperature or self.ai_config['temperature'],
                "max_tokens": max_tokens or self.ai_config['max_tokens']
            }
            
            response = requests.post(
                url,
                headers=self.headers,
                json=payload,
                timeout=30
            )
            
            if response.status_code == 200:
                result = response.json()
                return result['choices'][0]['message']['content']
            else:
                error_msg = response.text
                logger.error(f"AI API 调用失败: {error_msg}")
                raise Exception(f"API调用失败: {error_msg}")
                
        except Exception as e:
            logger.error(f"调用 AI API 时出错: {str(e)}")
            raise
    
    def _get_assistant_config(self, assistant_type: str) -> Dict:
        """获取助手配置"""
        return self.ai_config['assistant_types'].get(assistant_type, {})
    
    def analyze_content(self, content: str, analysis_type: str, include_suggestions: bool) -> dict:
        """分析内容"""
        try:
            prompt = f"""
请分析以下内容，提供详细的分析报告：

内容：
{content}

分析类型：{analysis_type}
{' 请包含改进建议' if include_suggestions else ''}

请提供：
1. 主要观点/要点提取
2. 内容结构分析
3. 关键信息识别
4. {'改进建议和优化方向' if include_suggestions else ''}
"""
            
            response = self.call_ai_api(prompt, temperature=0.3)
            return self._parse_analysis_response(response)
            
        except Exception as e:
            logger.error(f"内容分析失败: {str(e)}")
            raise
    
    def generate_plan(
        self,
        requirements: str,
        plan_type: str,
        duration: str,
        include_milestones: bool
    ) -> dict:
        """生成计划"""
        try:
            assistant_config = self._get_assistant_config('planner')
            prompt_template = assistant_config['prompts']['plan_creation']
            
            prompt = prompt_template.format(
                input=f"""
需求：{requirements}
计划类型：{plan_type}
时间跨度：{duration}
是否包含里程碑：{'是' if include_milestones else '否'}
"""
            )
            
            response = self.call_ai_api(
                prompt,
                temperature=assistant_config['temperature']
            )
            return self._parse_plan_response(response)
            
        except Exception as e:
            logger.error(f"计划生成失败: {str(e)}")
            raise
    
    def enhance_note_content(self, content: str, style: str = 'structured') -> str:
        """优化笔记内容"""
        try:
            prompt = f"""
请优化以下笔记内容，使其更加{style}和清晰：

原始内容：
{content}

请：
1. 优化内容结构
2. 突出重点内容
3. 补充必要的细节
4. 确保逻辑连贯
5. 添加适当的标题和小标题
"""
            
            response = self.call_ai_api(prompt, temperature=0.4)
            return response.strip()
            
        except Exception as e:
            logger.error(f"笔记优化失败: {str(e)}")
            raise
    
    def create_schedule(self, content: str, user_id: int, schedule_type: str = 'task') -> dict:
        """创建日程"""
        try:
            # 分析日程内容
            schedule_data = self.analyze_schedule_content(content)
            
            # 创建日程记录
            schedule = self._create_schedule_record(
                user_id=user_id,
                title=schedule_data['title'],
                start_time=schedule_data['start_time'],
                end_time=schedule_data['end_time'],
                schedule_type=schedule_type,
                content=content
            )
            
            return schedule
            
        except Exception as e:
            logger.error(f"创建日程失败: {str(e)}")
            raise

    def _create_schedule_record(self, **kwargs):
        """创建日程记录"""
        from apps.schedule.models import Event  # 避免循环导入
        
        try:
            schedule = Event.objects.create(
                user_id=kwargs['user_id'],
                title=kwargs['title'],
                start_time=kwargs['start_time'],
                end_time=kwargs['end_time'],
                event_type=kwargs['schedule_type'],
                description=kwargs['content']
            )
            return schedule
        except Exception as e:
            logger.error(f"创建日程记录失败: {str(e)}")
            raise

    def generate_plan(self, requirements: str, plan_type: str, duration: str, settings: dict = None) -> dict:
        """生成计划"""
        try:
            # 构建提示词
            prompt = f"""
基于以下信息生成详细的计划：

需求：{requirements}
计划类型：{plan_type}
时间跨度：{duration}
设置：{json.dumps(settings, ensure_ascii=False) if settings else '默认'}

请生成包含以下内容的计划：
1. 总体目标和关键里程碑
2. 详细的任务分解（包含子任务）
3. 时间分配和进度检查点
4. 优先级设置
5. 潜在风险和应对策略
6. 所需资源清单
7. 提醒和检查机制
"""
            # 调用AI服务
            response = self.call_ai_api_sync(prompt, temperature=0.7)
            return self._parse_plan_response(response)
            
        except Exception as e:
            logger.error(f"生成计划失败: {str(e)}")
            raise

    def call_ai_api_sync(self, prompt: str, temperature: float = 0.7) -> str:
        """同步调用 AI API"""
        try:
            url = f"{self.api_base}/chat/completions"
            
            payload = {
                "model": self.ai_config['model'],
                "messages": [{"role": "user", "content": prompt}],
                "temperature": temperature,
                "max_tokens": self.ai_config['max_tokens']
            }
            
            response = requests.post(
                url,
                headers=self.headers,
                json=payload,
                timeout=30
            )
            
            if response.status_code == 200:
                result = response.json()
                return result['choices'][0]['message']['content']
            else:
                error_msg = response.text
                logger.error(f"AI API 调用失败: {error_msg}")
                raise Exception(f"API调用失败: {error_msg}")
                
        except Exception as e:
            logger.error(f"调用 AI API 时出错: {str(e)}")
            raise
    
    def generate_recommendations(self, user) -> list:
        """生成个性化推荐"""
        # TODO: 实现基于用户历史数据的推荐逻辑
        return [
            {
                'type': 'note',
                'title': '建议复习最近的笔记',
                'reason': '距离上次复习已经超过7天'
            },
            {
                'type': 'schedule',
                'title': '建议规划下周任务',
                'reason': '下周有多个重要日程'
            }
        ]
    
    def get_smart_reminders(self, user) -> list:
        """获取智能提醒"""
        # TODO: 实现基于用户日程和习惯的智能提醒
        return [
            {
                'type': 'task',
                'title': '完成项目报告',
                'due_date': '2024-03-20',
                'priority': 'high'
            },
            {
                'type': 'review',
                'title': '复习重要笔记',
                'suggested_time': '今晚8点',
                'reason': '考试临近'
            }
        ]
    
    def _parse_analysis_response(self, response: str) -> dict:
        """解析分析结果"""
        # TODO: 实现更复杂的解析逻辑
        return {
            'content': response,
            'timestamp': '分析时间'
        }
    
    def _parse_plan_response(self, response: str) -> dict:
        """解析计划结果"""
        # TODO: 实现更复杂的解析逻辑
        return {
            'content': response,
            'created_at': '创建时间'
        }
    
    def _parse_schedule_response(self, response: str) -> dict:
        """解析日程结果"""
        # TODO: 实现更复杂的解析逻辑
        return {
            'content': response,
            'timestamp': '创建时间'
        }

    def analyze_learning_style(self, user_data: Dict) -> Dict:
        """分析学习风格和习惯"""
        try:
            # 分析用户的学习行为数据
            notes_pattern = user_data.get('notes_pattern', [])
            study_times = user_data.get('study_times', [])
            interaction_history = user_data.get('interaction_history', [])
            
            prompt = f"""
基于以下学习行为数据，分析该学生的学习风格和特点：

笔记模式：{notes_pattern}
学习时间分布：{study_times}
互动历史：{interaction_history}

请提供：
1. 主要学习风格（视觉型/听觉型/动手型等）
2. 最佳学习时间段
3. 知识掌握特点
4. 学习效率提升建议
5. 个性化学习策略
"""
            response = self.call_ai_api(prompt, temperature=0.4)
            return self._parse_learning_analysis(response)
            
        except Exception as e:
            logger.error(f"学习风格分析失败: {str(e)}")
            raise

    def generate_adaptive_study_plan(
        self,
        user_id: int,
        course_data: Dict,
        learning_style: Dict,
        time_constraints: Dict
    ) -> Dict:
        """生成自适应学习计划"""
        try:
            # 获取课程难度分布
            difficulty_distribution = self._analyze_course_difficulty(course_data)
            
            # 获取用户的知识图谱
            knowledge_graph = self._get_user_knowledge_graph(user_id)
            
            prompt = f"""
基于以下信息生成个性化学习计划：

课程信息：{course_data}
学习风格：{learning_style}
时间限制：{time_constraints}
难度分布：{difficulty_distribution}
知识基础：{knowledge_graph}

要求：
1. 根据难度分布优化学习顺序
2. 考虑知识点关联性
3. 匹配个人学习风格
4. 适应时间约束
5. 设置阶段性目标
6. 包含复习和测试环节
"""
            response = self.call_ai_api(prompt, temperature=0.3)
            return self._parse_study_plan(response)
            
        except Exception as e:
            logger.error(f"生成学习计划失败: {str(e)}")
            raise

    def create_interactive_quiz(
        self,
        content: str,
        difficulty: str,
        style: str,
        knowledge_points: List[str]
    ) -> Dict:
        """创建交互式测验"""
        try:
            prompt = f"""
基于以下内容创建交互式测验：

学习内容：{content}
难度级别：{difficulty}
测验风格：{style}
知识点：{knowledge_points}

要求：
1. 创建多样化题型（选择、填空、简答等）
2. 设计递进式难度
3. 包含实时反馈和解释
4. 关联知识点提示
5. 提供错题分析
6. 生成知识点巩固建议
"""
            response = self.call_ai_api(prompt, temperature=0.4)
            return self._parse_quiz(response)
            
        except Exception as e:
            logger.error(f"创建测验失败: {str(e)}")
            raise

    def generate_collaborative_tasks(
        self,
        group_data: Dict,
        learning_objectives: List[str]
    ) -> Dict:
        """生成小组协作学习任务"""
        try:
            # 分析组员特点
            member_analysis = self._analyze_group_members(group_data)
            
            prompt = f"""
设计小组协作学习任务：

组员特点：{member_analysis}
学习目标：{learning_objectives}

要求：
1. 根据成员特长分配角色
2. 设计互补性任务
3. 促进知识共享和讨论
4. 包含同伴评价机制
5. 设置协作里程碑
6. 提供团队激励机制
"""
            response = self.call_ai_api(prompt, temperature=0.5)
            return self._parse_collaborative_tasks(response)
            
        except Exception as e:
            logger.error(f"生成协作任务失败: {str(e)}")
            raise

    def create_mind_palace(
        self,
        notes: List[Dict],
        learning_style: str,
        knowledge_structure: Dict
    ) -> Dict:
        """创建知识思维宫殿"""
        try:
            prompt = f"""
构建个性化知识思维宫殿：

学习笔记：{notes}
学习风格：{learning_style}
知识结构：{knowledge_structure}

要求：
1. 创建形象化的知识空间
2. 设计记忆关联路径
3. 构建多维知识链接
4. 整合复习检查点
5. 生成直观导图
6. 添加情境记忆提示
"""
            response = self.call_ai_api(prompt, temperature=0.4)
            return self._parse_mind_palace(response)
            
        except Exception as e:
            logger.error(f"创建思维宫殿失败: {str(e)}")
            raise

    def _analyze_group_members(self, group_data: Dict) -> Dict:
        """分析小组成员特点"""
        # TODO: 实现成员分析逻辑
        pass

    def _parse_learning_analysis(self, response: str) -> Dict:
        """解析学习风格分析结果"""
        # TODO: 实现解析逻辑
        pass

    def _parse_study_plan(self, response: str) -> Dict:
        """解析学习计划"""
        # TODO: 实现解析逻辑
        pass

    def _parse_quiz(self, response: str) -> Dict:
        """解析测验内容"""
        # TODO: 实现解析逻辑
        pass

    def _parse_collaborative_tasks(self, response: str) -> Dict:
        """解析协作任务"""
        # TODO: 实现解析逻辑
        pass

    def _parse_mind_palace(self, response: str) -> Dict:
        """解析思维宫殿结构"""
        # TODO: 实现解析逻辑
        pass

    def analyze_time_management(self, user_data: Dict) -> Dict:
        """分析时间管理模式"""
        try:
            schedule_data = user_data.get('schedule_history', [])
            task_completion = user_data.get('task_completion', [])
            productivity_peaks = user_data.get('productivity_peaks', [])
            
            prompt = f"""
基于以下数据分析该学生的时间管理特点：

日程历史：{schedule_data}
任务完成情况：{task_completion}
效率高峰期：{productivity_peaks}

请提供：
1. 时间管理风格分析
2. 效率高峰时段识别
3. 任务完成模式
4. 时间分配建议
5. 效率提升策略
"""
            response = self.call_ai_api(prompt, temperature=0.4)
            return self._parse_time_analysis(response)
            
        except Exception as e:
            logger.error(f"时间管理分析失败: {str(e)}")
            raise

    def generate_smart_schedule(
        self,
        user_id: int,
        tasks: List[Dict],
        deadlines: Dict,
        priorities: Dict,
        energy_pattern: Dict
    ) -> Dict:
        """生成智能日程安排"""
        try:
            # 获取用户的时间管理模式
            time_pattern = self._get_user_time_pattern(user_id)
            
            prompt = f"""
基于以下信息生成智能日程安排：

待办任务：{tasks}
截止时间：{deadlines}
优先级：{priorities}
精力分布：{energy_pattern}
时间模式：{time_pattern}

要求：
1. 根据优先级和截止时间排序
2. 匹配个人精力分布
3. 预留缓冲时间
4. 设置专注时段
5. 合理分配休息
6. 考虑任务依赖关系
"""
            response = self.call_ai_api(prompt, temperature=0.3)
            return self._parse_schedule(response)
            
        except Exception as e:
            logger.error(f"生成日程失败: {str(e)}")
            raise

    def create_project_workflow(
        self,
        project_data: Dict,
        team_size: int,
        timeline: Dict,
        resources: List[str]
    ) -> Dict:
        """创建项目工作流"""
        try:
            prompt = f"""
设计项目工作流程：

项目信息：{project_data}
团队规模：{team_size}
时间线：{timeline}
可用资源：{resources}

要求：
1. 任务分解和分配
2. 设置关键节点
3. 资源优化配置
4. 风险预警机制
5. 进度追踪方案
6. 团队协作流程
"""
            response = self.call_ai_api(prompt, temperature=0.4)
            return self._parse_workflow(response)
            
        except Exception as e:
            logger.error(f"创建工作流失败: {str(e)}")
            raise

    def optimize_study_efficiency(
        self,
        current_schedule: Dict,
        study_goals: List[str],
        available_time: Dict
    ) -> Dict:
        """优化学习效率"""
        try:
            prompt = f"""
优化学习计划和效率：

当前安排：{current_schedule}
学习目标：{study_goals}
可用时间：{available_time}

要求：
1. 识别时间浪费点
2. 优化任务排序
3. 建议专注技巧
4. 设计奖励机制
5. 调整学习环境
6. 制定应急预案
"""
            response = self.call_ai_api(prompt, temperature=0.4)
            return self._parse_optimization(response)
            
        except Exception as e:
            logger.error(f"优化效率失败: {str(e)}")
            raise

    def generate_deadline_strategy(
        self,
        tasks: List[Dict],
        available_resources: Dict,
        stress_level: int
    ) -> Dict:
        """生成截止日期应对策略"""
        try:
            prompt = f"""
制定截止日期应对策略：

任务列表：{tasks}
可用资源：{available_resources}
压力水平：{stress_level}

要求：
1. 任务优先级排序
2. 时间分配建议
3. 压力管理方案
4. 资源调配计划
5. 应急预案设计
6. 休息时间安排
"""
            response = self.call_ai_api(prompt, temperature=0.4)
            return self._parse_strategy(response)
            
        except Exception as e:
            logger.error(f"生成策略失败: {str(e)}")
            raise

    def _parse_time_analysis(self, response: str) -> Dict:
        """解析时间管理分析结果"""
        # TODO: 实现解析逻辑
        pass

    def _parse_schedule(self, response: str) -> Dict:
        """解析智能日程安排"""
        # TODO: 实现解析逻辑
        pass

    def _parse_workflow(self, response: str) -> Dict:
        """解析项目工作流"""
        # TODO: 实现解析逻辑
        pass

    def _parse_optimization(self, response: str) -> Dict:
        """解析学习效率优化结果"""
        # TODO: 实现解析逻辑
        pass

    def _parse_strategy(self, response: str) -> Dict:
        """解析截止日期应对策略"""
        # TODO: 实现解析逻辑
        pass

    def analyze_note_content(self, note_id: int, user_id: int) -> Dict:
        """分析笔记内容并提供建议"""
        try:
            note = Note.objects.get(id=note_id, user_id=user_id)
            
            prompt = f"""
分析以下笔记内容，提供建议和行动项：

标题：{note.title}
内容：{note.content}

请提供：
1. 关键词提取
2. 主要任务识别
3. 时间节点识别
4. 相关事项建议
5. 后续行动建议
"""
            response = self.call_ai_api(prompt, temperature=0.3)
            analysis_result = self._parse_note_analysis(response)
            
            # 生成建议的笔记和日程
            if analysis_result.get('suggested_tasks'):
                self._create_suggested_items(
                    user_id,
                    analysis_result['suggested_tasks'],
                    note.id
                )
            
            return analysis_result
            
        except Exception as e:
            logger.error(f"笔记分析失败: {str(e)}")
            raise

    def process_voice_command(
        self,
        audio_data: bytes,
        user_id: int,
        context: dict = None
    ) -> dict:
        """处理语音命令"""
        try:
            # 语音转文字
            text = self.voice_service.recognize_audio(audio_data)
            
            # 获取用户的 AI 助手
            assistant = self.get_assistant(user_id)
            
            # 分析语音内容
            analysis = assistant.analyze_user_input(text, 'voice')
            
            return {
                'original_text': text,
                'analysis': analysis,
                'suggested_actions': self._generate_actions(analysis, context)
            }
        except Exception as e:
            logger.error(f"处理语音命令失败: {str(e)}")
            raise

    def process_schedule_import(
        self,
        schedule_data: Dict,
        user_id: int,
        import_type: str = 'exam'  # exam/meeting
    ) -> Dict:
        """处理导入的日程表并创建相应内容"""
        try:
            # 分析日程表内容
            analysis_prompt = f"""
分析以下{import_type}安排表，提取关键信息：

内容：{schedule_data}

请提供：
1. 时间节点列表
2. 重要事项提取
3. 准备事项建议
4. 相关资源建议
5. 风险点识别
"""
            analysis_response = self.call_ai_api(analysis_prompt, temperature=0.3)
            schedule_analysis = self._parse_schedule_analysis(analysis_response)
            
            # 创建相关笔记和日程
            created_items = self._create_items_from_schedule(
                user_id,
                schedule_analysis,
                import_type
            )
            
            return {
                'success': True,
                'analysis': schedule_analysis,
                'created_items': created_items,
                'message': '日程处理成功'
            }
        except Exception as e:
            logger.error(f"处理日程导入失败: {str(e)}")
            return {
                'success': False,
                'error': str(e),
                'message': '日程处理失败'
            }

    def chat(self, message: str, context: dict = None, user_preferences: dict = None) -> str:
        """通用对话方法"""
        try:
            messages = []
            
            # 添加系统提示词
            if context and context.get('system_prompt'):
                messages.append({
                    "role": "system",
                    "content": context['system_prompt']
                })
            
            # 添加用户偏好
            if user_preferences:
                messages.append({
                    "role": "system",
                    "content": f"用户偏好：{json.dumps(user_preferences, ensure_ascii=False)}"
                })

            # 添加用户消息
            messages.append({
                "role": "user",
                "content": message
            })

            # 调用 AI 接口
            response = self._call_api(
                messages,
                temperature=self.model_config['general']['temperature'],
                max_tokens=self.model_config['general']['max_tokens']
            )

            return response.strip()

        except Exception as e:
            logger.error(f"AI 对话失败: {str(e)}")
            raise

    def generate_study_plan(self, content: str, message: str, duration: str = 'short_term') -> dict:
        """生成学习计划"""
        try:
            prompt = f"""请根据以下内容生成一个详细的学习计划：

内容：{content}
用户需求：{message}
计划周期：{duration}

请生成包含以下内容的计划：
1. 计划概述
2. 具体时间安排
3. 关键里程碑
4. 学习建议和提示"""

            response = self._call_api([{"role": "user", "content": prompt}])
            
            # 不尝试解析为 JSON，直接返回格式化的字典
            return {
                'overview': '学习计划',
                'schedule': [],
                'milestones': [],
                'tips': [],
                'content': response  # 将完整响应放在 content 字段中
            }

        except Exception as e:
            logger.error(f"生成学习计划失败: {str(e)}")
            raise

    def optimize_note(self, content: str, message: str) -> dict:
        """优化笔记内容"""
        try:
            # 构建提示词
            prompt = f"""请根据以下要求优化笔记内容：

原始内容：
{content}

用户需求：
{message}

请优化以下几个方面：
1. 结构清晰：使用合适的标题和层次
2. 重点突出：关键内容和重要概念
3. 逻辑连贯：内容之间的关联
4. 易于理解：清晰的表述和举例
5. 便于复习：添加复习要点

请直接返回优化后的完整内容，保持格式清晰。"""

            # 调用AI接口
            response = self._call_api(
                messages=[{
                    "role": "system",
                    "content": "你是一个专业的备忘录优化专家，擅长改进备忘录的结构和内容。"
                }, {
                    "role": "user",
                    "content": prompt
                }],
                temperature=self.model_config['optimization']['temperature'],
                max_tokens=self.model_config['optimization']['max_tokens']
            )

            return {
                'content': response,
                'type': 'note_optimization'
            }

        except Exception as e:
            logger.error(f"优化笔记失败: {str(e)}")
            raise

    def analyze_task(self, content: str, message: str) -> dict:
        """分析任务"""
        try:
            prompt = f"""请分析以下任务并提供分解建议：

任务内容：{content}
用户需求：{message}

请提供：
1. 子任务分解
2. 时间安排建议
3. 优先级建议
4. 执行建议
"""
            response = self._call_api([{"role": "user", "content": prompt}])
            
            return {
                'original': content,
                'analysis': response,
                'content': response  # 保持格式统一
            }

        except Exception as e:
            logger.error(f"分析任务失败: {str(e)}")
            raise

    def plan_time(self, content: str, message: str) -> dict:
        """时间规划"""
        try:
            prompt = f"""请根据以下内容提供时间管理建议：

内容：{content}
需求：{message}

请按以下格式返回JSON：
{{
    "schedule": {{"morning": [], "afternoon": [], "evening": []}},
    "focus_periods": ["时段1", "时段2"],
    "breaks": ["休息1", "休息2"],
    "tips": ["建议1", "建议2"]
}}"""

            response = self._call_api([{"role": "user", "content": prompt}])
            return json.loads(response)

        except Exception as e:
            logger.error(f"时间规划失败: {str(e)}")
            raise

    def recommend_resources(self, content: str, message: str, note_type: str) -> dict:
        """推荐学习资源"""
        try:
            prompt = f"""请根据以下内容推荐学习资源：

内容：{content}
需求：{message}
类型：{note_type}

请按以下格式返回JSON：
{{
    "books": ["书籍1", "书籍2"],
    "online_courses": ["课程1", "课程2"],
    "tools": ["工具1", "工具2"],
    "websites": ["网站1", "网站2"]
}}"""

            response = self._call_api([{"role": "user", "content": prompt}])
            return json.loads(response)

        except Exception as e:
            logger.error(f"推荐资源失败: {str(e)}")
            raise

    def prepare_exam(self, content: str, message: str) -> dict:
        """准备考试计划"""
        try:
            prompt = f"""请根据以下内容制定考试准备计划：

内容：{content}
需求：{message}

请按以下格式返回JSON：
{{
    "review_plan": {{"phase1": [], "phase2": [], "phase3": []}},
    "key_points": ["重点1", "重点2"],
    "practice_suggestions": ["建议1", "建议2"],
    "exam_tips": ["技巧1", "技巧2"]
}}"""

            response = self._call_api([{"role": "user", "content": prompt}])
            return json.loads(response)

        except Exception as e:
            logger.error(f"准备考试计划失败: {str(e)}")
            raise

    def generate_exam_review_plan(self, content: str, time_available: dict, message: str) -> dict:
        """生成考试复习计划"""
        try:
            prompt = f"""请根据以下信息生成一个详细的考试复习计划：

可用时间：{time_available['summary']}
学习内容：{content}
用户需求：{message}

请生成包含以下内容的计划：
1. 总体复习规划和时间分配
2. 每天具体的复习内容和时间安排
3. 重点难点内容的复习建议
4. 复习方法和技巧建议
5. 自测和检验方案

请以结构化的方式返回，包含明确的时间节点和具体任务。"""

            response = self._call_api([{
                "role": "system",
                "content": "你是一个专业的学习规划专家，特别擅长制定考试复习计划。"
            }, {
                "role": "user",
                "content": prompt
            }])

            return {
                'content': response,
                'time_info': time_available,
                'type': 'exam_review'
            }

        except Exception as e:
            logger.error(f"生成考试复习计划失败: {str(e)}")
            raise

    def _call_api(self, messages: list, temperature: float = 0.7, max_tokens: int = 1000) -> str:
        """调用 AI API"""
        try:
            headers = {
                'Authorization': f'Bearer {self.api_key}',
                'Content-Type': 'application/json'
            }

            data = {
                'model': self.ai_config['model'],
                'messages': messages,
                'temperature': temperature,
                'max_tokens': max_tokens
            }

            response = requests.post(
                f'{self.api_base}/chat/completions',
                headers=headers,
                json=data,
                timeout=30
            )

            if response.status_code == 200:
                result = response.json()
                return result['choices'][0]['message']['content']
            else:
                raise Exception(f"API调用失败: {response.text}")

        except Exception as e:
            logger.error(f"调用AI API失败: {str(e)}")
            raise

    def _get_system_prompt(self, note_type: str, intent: str) -> str:
        """根据笔记类型和用户意图生成系统提示词"""
        base_prompt = """你是一个专业的学习助手，主要帮助大学生提高学习效率和笔记质量。
作为一个AI助手，你需要：
1. 提供专业、准确、实用的建议
2. 使用清晰、易懂的语言
3. 给出具体、可执行的方案
4. 注重时间管理和效率提升
5. 帮助建立良好的学习习惯

在回答时：
- 直接回答用户问题，避免无关内容
- 保持专业性和实用性
- 语言自然友好
- 适合对话场景"""

        type_prompts = {
            'study': """这是一个学习笔记，请特别注意：
- 帮助提炼知识重点
- 建立知识关联
- 设计复习计划
- 提供记忆方法""",
            
            'task': """这是一个任务笔记，请特别注意：
- 任务分解和规划
- 时间节点安排
- 执行步骤建议
- 进度管理方法""",
        }

        intent_prompts = {
            'study_plan': """制定学习计划时，请注意：
- 计划要循序渐进
- 设置合理时间节点
- 包含复习和测试环节
- 预留调整缓冲时间
- 设置进度检查点""",
            
            'note_optimization': """优化笔记内容时，请注意：
- 保持原有重点内容
- 优化知识结构
- 添加必要解释
- 建立知识关联
- 突出关键概念""",
        }

        prompts = [base_prompt]
        if note_type in type_prompts:
            prompts.append(type_prompts[note_type])
        if intent in intent_prompts:
            prompts.append(intent_prompts[intent])
        
        return "\n\n".join(prompts)